home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d12 / cc02.arc / CRC2.C < prev    next >
Text File  |  1986-03-14  |  5KB  |  161 lines

  1. /*---------------------------------------------------------------------------*/
  2. /*    High Performance CRC Computation Routine                     */
  3. /*                                         */
  4. /*    Copyright 1985 W. David Schwaderer                     */
  5. /*     All rights reserved                             */
  6. /*                                         */
  7. /*    Compiler used :Computer Innovations C86  V2.10A                 */
  8. /*    Compiler used :Microsoft/Lattice C V2.03 (CFL)                 */
  9. /*                                         */
  10. /*     Warning...this program uses bit fields!                 */
  11. /*     For warnings on bit field hazards see :                 */
  12. /*                                         */
  13. /*    The C Wizard's Programming Reference Handbook                          */
  14. /*        W. David Schwaderer                          */
  15. /*     John Wiley and Sons, 1985                         */
  16. /*                                         */
  17. /*                                         */
  18. /*                                         */
  19. /*                                         */
  20. /*                                         */
  21. /*---------------------------------------------------------------------------*/
  22.  
  23. #include <stdio.h>
  24.  
  25. #define  VOID  int
  26.  
  27. unsigned crc_table[256];           /* globally accessible */
  28.  
  29. main(argc, argv)
  30. int     argc;
  31. char     *argv[];
  32. {
  33.       VOID     GenTable();
  34.       unsigned GenCRC();
  35.  
  36.       unsigned length, crc;
  37.  
  38.       static   char  TstArry1[] = {'\001','\000'};
  39.                        /* crc = 0x9001 */
  40.       static   char  TstArry2[] = {'\001','\000','\001','\220'};
  41.                        /* bytewise    bytewise */
  42.                        /* reversed    reversed */
  43.       static   char  TestMsg[] = "This is a test message.";
  44.  
  45.       GenTable();          /* fill in the crc_table */
  46.  
  47.       PrtTable();             /* display the table     */
  48.  
  49.       length = sizeof(TstArry1);
  50.       crc = GenCRC(length, TstArry1);
  51.                        /* calculate CRC */
  52.       printf("\n\n\nTstArry1 CRC = 0x%04x", crc);
  53.  
  54.       length = sizeof(TstArry2);
  55.       crc = GenCRC(length, TstArry2);
  56.                        /* calculate CRC */
  57.       printf("\n\n\nTstArry2 CRC = 0x%04x", crc);
  58.  
  59.       length = sizeof(TestMsg) - 1;    /* avoid terminating NUL */
  60.       crc = GenCRC(length, TestMsg);
  61.                        /* calculate CRC */
  62.       printf("\n\n\nText = [%s]\nCRC = 0x%04x\n\n", TestMsg, crc);
  63.  
  64.       return(0);
  65.  
  66. }
  67.  
  68. VOID  GenTable()          /* generate the look-up table */
  69. {
  70.       int   temp;
  71.       union {  int    i;
  72.            struct    {
  73.                unsigned      :8;          /* unused     */
  74.                unsigned i8      :1;          /* high order bit */
  75.                unsigned i7      :1;
  76.                unsigned i6      :1;
  77.                unsigned i5      :1;
  78.                unsigned i4      :1;
  79.                unsigned i3      :1;
  80.                unsigned i2      :1;
  81.                unsigned i1      :1;          /* low order bit    */
  82.            }  Bit;
  83.       }  iUn;
  84.       union {  unsigned int   Entry;
  85.            struct    {
  86.                unsigned b16   :1;          /* high order bit */
  87.                unsigned b15   :1;
  88.                unsigned b14   :1;
  89.                unsigned b13   :1;
  90.                unsigned b12   :1;
  91.                unsigned b11   :1;
  92.                unsigned b10   :1;
  93.                unsigned b9      :1;
  94.                unsigned b8      :1;
  95.                unsigned b7      :1;
  96.                unsigned b6      :1;
  97.                unsigned b5      :1;
  98.                unsigned b4      :1;
  99.                unsigned b3      :1;
  100.                unsigned b2      :1;
  101.                unsigned b1      :1;          /* low order bit */
  102.            }  EntryBit;
  103.       }  EntryUn;
  104.  
  105.       for (iUn.i = 0; iUn.i < 256; iUn.i++) {
  106.  
  107.      EntryUn.Entry = 0;           /* bits 2 thru 6 zeroed out now */
  108.  
  109.      temp = (iUn.Bit.i7 ^ iUn.Bit.i6 ^ iUn.Bit.i5 ^ iUn.Bit.i4 ^
  110.          iUn.Bit.i3 ^ iUn.Bit.i2 ^ iUn.Bit.i1);
  111.  
  112.      EntryUn.EntryBit.b16 = (iUn.Bit.i8 ^ temp);
  113.      EntryUn.EntryBit.b15 = (temp);
  114.      EntryUn.EntryBit.b14 = (iUn.Bit.i8 ^ iUn.Bit.i7);
  115.      EntryUn.EntryBit.b13 = (iUn.Bit.i7 ^ iUn.Bit.i6);
  116.      EntryUn.EntryBit.b12 = (iUn.Bit.i6 ^ iUn.Bit.i5);
  117.      EntryUn.EntryBit.b11 = (iUn.Bit.i5 ^ iUn.Bit.i4);
  118.      EntryUn.EntryBit.b10 = (iUn.Bit.i4 ^ iUn.Bit.i3);
  119.      EntryUn.EntryBit.b9  = (iUn.Bit.i3 ^ iUn.Bit.i2);
  120.      EntryUn.EntryBit.b8  = (iUn.Bit.i2 ^ iUn.Bit.i1);
  121.      EntryUn.EntryBit.b7  = (iUn.Bit.i1);
  122.      EntryUn.EntryBit.b1  = (iUn.Bit.i8 ^ temp);
  123.  
  124.      crc_table[iUn.i] = EntryUn.Entry;
  125.       }
  126. }
  127.  
  128. VOID  PrtTable()             /* print out the look-up table */
  129. {
  130.       int   i;
  131.  
  132.       for (i = 0; i < 256; i++) {
  133.      if ( !(i % 8) )
  134.         printf("\n %02x  -  %04x", i, crc_table[i]);
  135.      else
  136.         printf("  %04x", crc_table[i]);
  137.       }
  138. }
  139.  
  140. unsigned GenCRC(Length, TextPtr)
  141. unsigned Length;
  142. char     *TextPtr;
  143. {
  144.       int      i, index;
  145.       unsigned crc;
  146.  
  147.       crc = 0;                   /* crc starts at zero for each msg */
  148.  
  149.       for (i = 0; i < Length; i++, TextPtr++) {
  150.      index = ((crc ^ *TextPtr) & 0x00FF);
  151.      crc = ((crc >> 8) & 0x00FF) ^ crc_table[index];
  152.       }
  153.  
  154.       return(crc);
  155. }
  156.  
  157.  
  158.  
  159.  
  160.  
  161.